/**
 * Babel Service代码运行时转换插件
 * 用于小程序端，在构建阶段直接处理srcService中的服务文件
 * 移除TypeScript类型注解和Node.js特定依赖，适配小程序环境
 */

module.exports = function(api) {
  api.cache(true);
  
  return {
    name: 'babel-service-runtime-transform',
    visitor: {
      // 处理导入声明
      ImportDeclaration(path) {
        try {
          // 确保path.node.source存在
          if (path.node?.source?.value) {
            // 移除Node.js特定模块的导入
            const nodeModulesToRemove = ['os', 'express', 'path', 'fs', 'crypto', 'http', 'https', 'net', 'tls'];
            if (nodeModulesToRemove.includes(path.node.source.value)) {
              path.remove();
              return;
            }
            
            // 处理numeral等第三方库，在小程序环境中提供空实现
            if (path.node.source.value === 'numeral' && Array.isArray(path.node.specifiers)) {
              // 替换为小程序环境的替代实现
              const numeralImport = path.node.specifiers.find(s => s.type === 'ImportDefaultSpecifier');
              if (numeralImport && numeralImport.local && numeralImport.local.name) {
                // 创建一个全局的numeral替代实现
                path.replaceWith(api.template.ast(`const ${numeralImport.local.name} = { format: (num) => String(num) };`));
              }
            }
          }
        } catch (error) {
          console.error('处理ImportDeclaration时出错:', error);
        }
      },
      
      // 移除TypeScript类型注解
      TSTypeAnnotation(path) {
        try {
          path.remove();
        } catch (error) {
          console.error('移除TSTypeAnnotation时出错:', error);
        }
      },
      
      // 移除TypeScript类型参数
      TSTypeParameter(path) {
        try {
          path.remove();
        } catch (error) {
          console.error('移除TSTypeParameter时出错:', error);
        }
      },
      
      // 移除TypeScript类型断言
      TSAsExpression(path) {
        try {
          if (path.node?.expression) {
            path.replaceWith(path.node.expression);
          }
        } catch (error) {
          console.error('处理TSAsExpression时出错:', error);
        }
      },
      
      // 移除TypeScript接口声明
      TSInterfaceDeclaration(path) {
        try {
          path.remove();
        } catch (error) {
          console.error('移除TSInterfaceDeclaration时出错:', error);
        }
      },
      
      // 移除TypeScript类型别名
      TSTypeAliasDeclaration(path) {
        try {
          path.remove();
        } catch (error) {
          console.error('移除TSTypeAliasDeclaration时出错:', error);
        }
      },
      
      // 处理类声明
      ClassDeclaration(path) {
        try {
          // 处理ServiceBase和UtilsService的构造函数
          if ((path.node?.superClass?.name === 'ServiceBase') || (path.node?.id?.name === 'UtilsService')) {
            // 查找构造函数
            if (path.node?.body && Array.isArray(path.node.body.body)) {
              const constructor = path.get('body.body').find(
                method => method && method.isClassMethod && method.isClassMethod() && 
                         method.node && method.node.key && method.node.key.name === 'constructor'
              );
              
              if (constructor && constructor.node) {
                // 修改构造函数，移除参数和类型
                constructor.node.params = [];
                // 移除构造函数体中的所有内容，避免调用不存在的模块
                if (constructor.node.body && Array.isArray(constructor.node.body.body)) {
                  constructor.node.body.body = [];
                }
              }
            }
          }
        } catch (error) {
          console.error('处理ClassDeclaration时出错:', error);
        }
      },
      
      // 处理MemberExpression，替换Node.js API调用
      MemberExpression(path) {
        try {
          if (path.node?.object?.name === 'os') {
            // 替换os相关属性引用
            if (['cpus', 'totalmem', 'freemem'].includes(path.node.property.name)) {
              // 仅记录，在CallExpression中实际替换值
            }
          }
          // 处理process.env引用
            if (path.node?.object?.object?.name === 'process' && path.node?.object?.property?.name === 'env') {
              path.replaceWith(t.nullLiteral());
            }
        } catch (error) {
          console.error('处理MemberExpression时出错:', error);
        }
      },
      
      // 处理类方法，移除参数类型
      ClassMethod(path) {
        try {
          // 移除所有参数的类型注解
          if (Array.isArray(path.node?.params)) {
            path.node.params.forEach(param => {
              if (param) {
                delete param.typeAnnotation;
              }
            });
          }
          
          // 移除返回类型注解
          delete path.node?.returnType;
        } catch (error) {
          console.error('处理ClassMethod时出错:', error);
        }
      },
      
      // 处理可能使用了Node.js API的函数调用
      CallExpression(path) {
        try {
          // 安全地检查callee
          if (path.get('callee') && typeof path.get('callee').matchesPattern === 'function') {
            // 处理os相关API调用
              if (path.get('callee').matchesPattern('os.cpus')) {
                path.replaceWith(t.arrayExpression([])); // 空数组替代
              } else if (path.get('callee').matchesPattern('os.totalmem')) {
                path.replaceWith(t.numericLiteral(0)); // 使用0替代
              } else if (path.get('callee').matchesPattern('os.freemem')) {
                path.replaceWith(t.numericLiteral(0)); // 使用0替代
              }
            }
            // 直接检查对象属性方式
            if (path.node?.callee?.object?.name === 'os') {
              if (path.node.callee.property.name === 'cpus') {
                path.replaceWith(t.arrayExpression([]));
              } else if (path.node.callee.property.name === 'totalmem') {
                path.replaceWith(t.numericLiteral(0));
              } else if (path.node.callee.property.name === 'freemem') {
                path.replaceWith(t.numericLiteral(0));
              }
          }
        } catch (error) {
          console.error('处理CallExpression时出错:', error);
        }
      },
      
      // 处理变量声明，移除类型注解
      VariableDeclarator(path) {
        try {
          if (path.node?.id) {
            delete path.node.id.typeAnnotation;
          }
        } catch (error) {
          console.error('处理VariableDeclarator时出错:', error);
        }
      }
    }
  };
};